Settings.h

Go to the documentation of this file.

/*[
 * This file is part of the Zivid 3D Camera API
 *
 * Copyright 2015-2018 (C) Zivid Labs. All rights reserved.
 * Contact info@zividlabs.com or see http://www.zividlabs.com
 * 
 * This code is proprietary and confidential.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
]*/

#pragma once


#include <chrono>
#include <ctime>
#include <iomanip>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "APIExport.h"
#include "Range.h"

#ifdef __has_include
#if __has_include("SettingsInternal.h")
#include "SettingsInternal.h"
#else
namespace Zivid {
class SettingsInternal;
}
#endif
#else
namespace Zivid {
class SettingsInternal;
}
#endif

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

namespace Zivid {
class ZIVID_COMMON Settings {
public:
  Settings();
  ~Settings();
  Settings(const Settings &other);
  Settings &operator=(const Settings &other);
  Settings(Settings &&other) noexcept;
  Settings &operator=(Settings &&other) noexcept;

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

  static constexpr bool isContainer{true};

  static constexpr const char *path{""};

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

  void set(const std::string &fullPath, const std::string &value);

  std::string getString(const std::string &fullPath) const;

  class ZIVID_COMMON BlueBalance {
  public:
    using ValueType = double;

    static constexpr bool isContainer{false};

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

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

    BlueBalance() = default;

    explicit constexpr BlueBalance(ValueType value) noexcept(
        std::is_nothrow_move_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 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_COMMON RedBalance {
  public:
    using ValueType = double;

    static constexpr bool isContainer{false};

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

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

    RedBalance() = default;

    explicit constexpr RedBalance(ValueType value) noexcept(
        std::is_nothrow_move_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 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};
  };

  class ZIVID_COMMON ExposureTime {
  public:
    using ValueType = std::chrono::microseconds;

    static constexpr bool isContainer{false};

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

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

    ExposureTime() = default;

    explicit constexpr ExposureTime(ValueType value) noexcept(
        std::is_nothrow_move_constructible<ValueType>::value)
        : m_value{value} {}

    const ValueType &value() const { return m_value; }

    Range<ValueType> range() const {
      return {ValueType{8333}, 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_COMMON Iris {
  public:
    using ValueType = size_t;

    static constexpr bool isContainer{false};

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

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

    Iris() = default;

    explicit constexpr Iris(ValueType value) noexcept(
        std::is_nothrow_move_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_COMMON Brightness {
  public:
    using ValueType = double;

    static constexpr bool isContainer{false};

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

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

    Brightness() = default;

    explicit constexpr Brightness(ValueType value) noexcept(
        std::is_nothrow_move_constructible<ValueType>::value)
        : m_value{value} {}

    const ValueType &value() const { return m_value; }

    Range<ValueType> range() const { return {0, 1}; }

    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_COMMON 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"};

    Bidirectional() = default;

    explicit constexpr Bidirectional(ValueType value) noexcept(
        std::is_nothrow_move_constructible<ValueType>::value)
        : m_value{value} {}

    const ValueType &value() const { return m_value; }

    void setFromString(const std::string &value) { m_value = (value == "yes"); }

    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_COMMON Filters {
  public:
    Filters() = default;

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

    static constexpr bool isContainer{true};

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

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

    void set(const std::string &fullPath, const std::string &value);

    std::string getString(const std::string &fullPath) const;

    class ZIVID_COMMON Contrast {
    public:
      Contrast() = default;

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

      static constexpr bool isContainer{true};

      static constexpr const char *path{"Filters/Contrast"};

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

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON Threshold {
      public:
        using ValueType = double;

        static constexpr bool isContainer{false};

        static constexpr const char *path{"Filters/Contrast/Threshold"};

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

        Threshold() = default;

        explicit constexpr Threshold(ValueType value) noexcept(
            std::is_nothrow_move_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};
      };

    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("Contrast: " + std::to_string(value.value()) +
                                  ", is out of 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_threshold); }

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

      template <typename F> void traverseValues(const F &f) const {
        f(m_threshold);
      }

      template <typename F> void traverseValues(const F &f) { f(m_threshold); }

      std::string toString() const;

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

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

      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;
      }

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

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

      bool operator!=(const Contrast &other) const;
    };

    class ZIVID_COMMON Outlier {
    public:
      Outlier() = default;

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

      static constexpr bool isContainer{true};

      static constexpr const char *path{"Filters/Outlier"};

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

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON 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"};

        Enabled() = default;

        explicit constexpr Enabled(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{value} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) {
          m_value = (value == "yes");
        }

        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_COMMON Threshold {
      public:
        using ValueType = double;

        static constexpr bool isContainer{false};

        static constexpr const char *path{"Filters/Outlier/Threshold"};

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

        Threshold() = default;

        explicit constexpr Threshold(ValueType value) noexcept(
            std::is_nothrow_move_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};
      };

    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("Outlier: " + std::to_string(value.value()) +
                                  ", is out of 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 save(const std::string &fileName) const;

      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;
      }

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

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

      bool operator!=(const Outlier &other) const;
    };

    class ZIVID_COMMON Saturated {
    public:
      Saturated() = default;

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

      static constexpr bool isContainer{true};

      static constexpr const char *path{"Filters/Saturated"};

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

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON 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"};

        Enabled() = default;

        explicit constexpr Enabled(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{value} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) {
          m_value = (value == "yes");
        }

        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};
      };

    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 save(const std::string &fileName) const;

      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;
      }

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

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

      bool operator!=(const Saturated &other) const;
    };

    class ZIVID_COMMON Reflection {
    public:
      Reflection() = default;

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

      static constexpr bool isContainer{true};

      static constexpr const char *path{"Filters/Reflection"};

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

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON 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"};

        Enabled() = default;

        explicit constexpr Enabled(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{value} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) {
          m_value = (value == "yes");
        }

        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};
      };

    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 save(const std::string &fileName) const;

      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;
      }

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

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

      bool operator!=(const Reflection &other) const;
    };

  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::Threshold &value) {

      if (value.value() < value.range().min() ||
          value.value() > value.range().max()) {
        throw std::out_of_range("Filters: " + std::to_string(value.value()) +
                                ", is out of range: {" +
                                std::to_string(value.range().min()) + ", " +
                                std::to_string(value.range().max()) + "}");
      }

      m_contrast.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) {

      if (value.value() < value.range().min() ||
          value.value() > value.range().max()) {
        throw std::out_of_range("Filters: " + std::to_string(value.value()) +
                                ", is out of range: {" +
                                std::to_string(value.range().min()) + ", " +
                                std::to_string(value.range().max()) + "}");
      }

      m_outlier.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;
    }

  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;
    }

    template <typename F> void forEach(const F &f) const {
      f(m_contrast);
      f(m_outlier);
      f(m_saturated);
      f(m_reflection);
    }

    template <typename F> void forEach(const F &f) {
      f(m_contrast);
      f(m_outlier);
      f(m_saturated);
      f(m_reflection);
    }

    template <typename F> void traverseValues(const F &f) const {
      m_contrast.traverseValues(f);
      m_outlier.traverseValues(f);
      m_saturated.traverseValues(f);
      m_reflection.traverseValues(f);
    }

    template <typename F> void traverseValues(const F &f) {
      m_contrast.traverseValues(f);
      m_outlier.traverseValues(f);
      m_saturated.traverseValues(f);
      m_reflection.traverseValues(f);
    }

    std::string toString() const;

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

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

    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;
    }

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

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

    bool operator!=(const Filters &other) const;
  };

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("Settings: " + std::to_string(value.value()) +
                              ", is out of 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:
  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("Settings: " + std::to_string(value.value()) +
                              ", is out of 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; }

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(
          "Settings: " + std::to_string(value.value().count()) +
          ", is out of 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:
  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("Settings: " + std::to_string(value.value()) +
                              ", is out of 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:
  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("Settings: " + std::to_string(value.value()) +
                              ", is out of 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:
  Bidirectional m_bidirectional{};

public:
  Settings &set(const Bidirectional &value) {

    m_bidirectional = value;
    return *this;
  }
  const Bidirectional &bidirectional() const { return m_bidirectional; }

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::Threshold &value) {

    if (value.value() < value.range().min() ||
        value.value() > value.range().max()) {
      throw std::out_of_range("Settings: " + std::to_string(value.value()) +
                              ", is out of range: {" +
                              std::to_string(value.range().min()) + ", " +
                              std::to_string(value.range().max()) + "}");
    }

    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) {

    if (value.value() < value.range().min() ||
        value.value() > value.range().max()) {
      throw std::out_of_range("Settings: " + std::to_string(value.value()) +
                              ", is out of range: {" +
                              std::to_string(value.range().min()) + ", " +
                              std::to_string(value.range().max()) + "}");
    }

    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;
  }

  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;
  }

  template <typename F> void forEach(const F &f) const {
    f(m_blueBalance);
    f(m_redBalance);
    f(m_exposureTime);
    f(m_iris);
    f(m_brightness);
    f(m_bidirectional);
    f(m_filters);
  }

  template <typename F> void forEach(const F &f) {
    f(m_blueBalance);
    f(m_redBalance);
    f(m_exposureTime);
    f(m_iris);
    f(m_brightness);
    f(m_bidirectional);
    f(m_filters);
  }

  template <typename F> void traverseValues(const F &f) const {
    f(m_blueBalance);
    f(m_redBalance);
    f(m_exposureTime);
    f(m_iris);
    f(m_brightness);
    f(m_bidirectional);
    m_filters.traverseValues(f);
  }

  template <typename F> void traverseValues(const F &f) {
    f(m_blueBalance);
    f(m_redBalance);
    f(m_exposureTime);
    f(m_iris);
    f(m_brightness);
    f(m_bidirectional);
    m_filters.traverseValues(f);
  }

  std::string toString() const;

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

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

  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;
  }

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

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

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  SettingsInternal &getSettingsInternal() { return *m_internal; }
  const SettingsInternal &getSettingsInternal() const { return *m_internal; }
#endif // DOXYGEN_SHOULD_SKIP_THIS
private:
  std::unique_ptr<SettingsInternal> m_internal;
};
} // namespace Zivid

#ifdef _MSC_VER
#pragma warning(pop)
#endif